.TH std::unordered_multimap 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::unordered_multimap \- std::unordered_multimap

.SH Synopsis
   Defined in header <unordered_map>
   template<

       class Key,
       class T,
       class Hash = std::hash<Key>,                                   \fB(1)\fP \fI(since C++11)\fP
       class KeyEqual = std::equal_to<Key>,
       class Allocator = std::allocator<std::pair<const Key, T>>

   > class unordered_multimap;
   namespace pmr {

       template<
           class Key,
           class T,
           class Hash = std::hash<Key>,
           class Pred = std::equal_to<Key>                            \fB(2)\fP \fI(since C++17)\fP
       > using unordered_multimap =
             std::unordered_multimap<Key, T, Hash, Pred,
                 std::pmr::polymorphic_allocator<std::pair<const Key,
   T>>>;

   }

   std::unordered_multimap is an unordered associative container that supports
   equivalent keys (an unordered_multimap may contain multiple copies of each key
   value) and that associates values of another type with the keys. The
   unordered_multimap class supports forward iterators. Search, insertion, and removal
   have average constant-time complexity.

   Internally, the elements are not sorted in any particular order, but organized into
   buckets. Which bucket an element is placed into depends entirely on the hash of its
   key. This allows fast access to individual elements, since once the hash is
   computed, it refers to the exact bucket the element is placed into.

   The iteration order of this container is not required to be stable (so, for example,
   std::equal cannot be used to compare two std::unordered_multimaps), except that
   every group of elements whose keys compare equivalent (compare equal with key_eq()
   as the comparator) forms a contiguous subrange in the iteration order, also
   accessible with equal_range().

   std::unordered_multimap meets the requirements of Container,
   AllocatorAwareContainer, UnorderedAssociativeContainer.

.SH Template parameters

    This section is incomplete
    Reason: Add descriptions of the template parameters.

.SH Member types

   Member type             Definition
   key_type                Key
   mapped_type             T
   value_type              std::pair<const Key, T>
   size_type               Unsigned integer type (usually std::size_t)
   difference_type         Signed integer type (usually std::ptrdiff_t)
   hasher                  Hash
   key_equal               KeyEqual
   allocator_type          Allocator
   reference               value_type&
   const_reference         const value_type&
   pointer                 std::allocator_traits<Allocator>::pointer
   const_pointer           std::allocator_traits<Allocator>::const_pointer
   iterator                LegacyForwardIterator to value_type
   const_iterator          LegacyForwardIterator to const value_type
                           An iterator type whose category, value, difference, pointer
                           and
   local_iterator          reference types are the same as iterator. This iterator
                           can be used to iterate through a single bucket but not
                           across buckets
                           An iterator type whose category, value, difference, pointer
                           and
   const_local_iterator    reference types are the same as const_iterator. This
                           iterator
                           can be used to iterate through a single bucket but not
                           across buckets
   node_type \fI(since C++17)\fP a specialization of node handle representing a container
                           node

.SH Member functions

   constructor       constructs the unordered_multimap
                     \fI(public member function)\fP
   destructor        destructs the unordered_multimap
                     \fI(public member function)\fP
   operator=         assigns values to the container
                     \fI(public member function)\fP
   get_allocator     returns the associated allocator
                     \fI(public member function)\fP
.SH Iterators
   begin             returns an iterator to the beginning
   cbegin            \fI(public member function)\fP
   end               returns an iterator to the end
   cend              \fI(public member function)\fP
.SH Capacity
   empty             checks whether the container is empty
                     \fI(public member function)\fP
   size              returns the number of elements
                     \fI(public member function)\fP
   max_size          returns the maximum possible number of elements
                     \fI(public member function)\fP
.SH Modifiers
   clear             clears the contents
                     \fI(public member function)\fP
                     inserts elements
   insert            or nodes
                     \fI(since C++17)\fP
                     \fI(public member function)\fP
   insert_range      inserts a range of elements
   (C++23)           \fI(public member function)\fP
   emplace           constructs element in-place
                     \fI(public member function)\fP
   emplace_hint      constructs elements in-place using a hint
                     \fI(public member function)\fP
   erase             erases elements
                     \fI(public member function)\fP
   swap              swaps the contents
                     \fI(public member function)\fP
   extract           extracts nodes from the container
   \fI(C++17)\fP           \fI(public member function)\fP
   merge             splices nodes from another container
   \fI(C++17)\fP           \fI(public member function)\fP
.SH Lookup
   count             returns the number of elements matching specific key
                     \fI(public member function)\fP
   find              finds element with specific key
                     \fI(public member function)\fP
   contains          checks if the container contains element with specific key
   (C++20)           \fI(public member function)\fP
   equal_range       returns range of elements matching a specific key
                     \fI(public member function)\fP
.SH Bucket interface
   begin(size_type)  returns an iterator to the beginning of the specified bucket
   cbegin(size_type) \fI(public member function)\fP
   end(size_type)    returns an iterator to the end of the specified bucket
   cend(size_type)   \fI(public member function)\fP
   bucket_count      returns the number of buckets
                     \fI(public member function)\fP
   max_bucket_count  returns the maximum number of buckets
                     \fI(public member function)\fP
   bucket_size       returns the number of elements in specific bucket
                     \fI(public member function)\fP
   bucket            returns the bucket for specific key
                     \fI(public member function)\fP
.SH Hash policy
   load_factor       returns average number of elements per bucket
                     \fI(public member function)\fP
   max_load_factor   manages maximum average number of elements per bucket
                     \fI(public member function)\fP
                     reserves at least the specified number of buckets and regenerates
   rehash            the hash table
                     \fI(public member function)\fP
                     reserves space for at least the specified number of elements and
   reserve           regenerates the hash table
                     \fI(public member function)\fP
.SH Observers
   hash_function     returns function used to hash the keys
                     \fI(public member function)\fP
   key_eq            returns the function used to compare keys for equality
                     \fI(public member function)\fP

.SH Non-member functions

   operator==
   operator!=                         compares the values in the unordered_multimap
   \fI(C++11)\fP                            \fI(function template)\fP
   \fI(C++11)\fP(removed in C++20)
   std::swap(std::unordered_multimap) specializes the std::swap algorithm
   \fI(C++11)\fP                            \fI(function template)\fP
   erase_if(std::unordered_multimap)  erases all elements satisfying specific criteria
   (C++20)                            \fI(function template)\fP

     Deduction guides \fI(since C++17)\fP

.SH Notes

       Feature-test macro       Value    Std                   Feature
   __cpp_lib_containers_ranges 202202L (C++23) Ranges construction and insertion for
                                               containers

.SH Example

    This section is incomplete
    Reason: no example

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to          Behavior as published              Correct behavior
                       the definitions of reference,
   LWG 2050 C++11      const_reference, pointer                 based on value_type and
                       and const_pointer were based on          std::allocator_traits
                       allocator_type

.SH Categories:
     * Todo with reason
     * Todo no example
